﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
//class A
//{
//public:
//	int _a[128];
//};
//
// class B : public A
////class B : virtual public A
//{
//public:
//	int _b;
//};
//
//class C : public A
////class C : virtual public A
//{
//public:
//	int _c;
//};
//
//class D : public B, public C
//{
//public:
//	int _d;
//};
//
//int main()
//{
//	D d;
//	//d.B::_a = 1;
//	//d.C::_a = 2;
//	d._b = 3;
//	d._c = 4;
//	d._d = 5;
//
//	cout << sizeof(D) << endl;
//
//	return 0;
//}

//#include <iostream>
//using namespace std;
//
//struct A {
//    int a;
//};
//
//struct B {
//    int b;
//};
//
//struct D : A, B {
//    int d;
//};
//
//int main() {
//    cout << sizeof(D) << endl;
//}

//#include <iostream>
//using namespace std;
//
//struct A { int a; };
//struct B : virtual A { int b; };//在 B 对象的内存中，大概长这样：
//                                //+------------+---------+-----------+
//                                //| vbptr      | b       |  padding  |
//                                //+------------+---------+-----------+
//                                //vbptr 是个 8 字节指针，指向 vbtable
//                                //vbtable 里存着：从当前对象到 A 的偏移量（比如 + 16）
//struct C : virtual A { int c; };
//struct D : B, C { int d; };     
//
//
////D对象的内存布局（64位）：
////| B::vbptr | B::b | padding | C::vbptr | C::c | padding | A::a | D::d |
//
//int main() 
//{
//    B b;
//    D obj;
//    cout << "sizeof(A): " << sizeof(A) << endl;
//    cout << "sizeof(B): " << sizeof(B) << endl;
//    cout << "sizeof(C): " << sizeof(C) << endl;
//    cout << "sizeof(D): " << sizeof(D) << endl;
//    return 0;
//}


//class A
//{
//public:
//	A(const char* msg)
//	{
//		cout << "A(const char* msg)" << endl;
//	}
//};
//class B :virtual public A
//{
//public:
//	B(const char* a, const char* b)
//		:A(a)
//	{
//		cout << "B(const char* a, const char* b)" << endl;
//	}
//};
//
//class C : virtual public A {
//public:
//	C(const char* a, const char* c) 
//		: A(a) 
//	{ 
//		cout << "C(const char* a, const char* c) " << endl; 
//	}
//};
//
//class D : public B, public C {
//public:
//	D(const char* a, const char* b, const char* c, const char* d)
//		: A(a), B(a, b), C(a, c)
//	{
//		cout << "D(const char* a, const char* b, const char* c, const char* d) " << endl;
//	}
//};
//int main()
//{
//    D d("a", "b", "c", "d");
//    return 0;
//}


//#include <iostream>
//using namespace std;
//
//class Person {
//public:
//    virtual void BuyTicket() const {
//        cout << "Person buying a ticket" << endl;
//    }
//};
//
//class Student : public Person {
//public:
//    virtual void BuyTicket() const override {
//        cout << "Student buying a ticket with discount" << endl;
//    }
//};
////“子类产生多态，子类内部会自动产生一个指针（vptr），指向一个表（vtable），
//// 表里面存放的是函数地址。”
//
//void func(const Person* p) {
//    p->BuyTicket();  // 多态调用
//}
//
////每个类只生成一张 vtable（静态存储区，不是每个对象都一份）。
////每个对象有一份 vptr，指向它所属类的 vtable。
////调用虚函数时，通过 vptr->vtable[index] 跳转调用。
////所以虚函数调用比普通函数略慢一丢丢（因为多了一次间接跳转）。
//
//
//int main() {
//   /* Person person;
//    Student student;*/
//    Person* p1 = new Person();
//    Person* p2 = new Student();
//    func(p1);
//    func(p2);
//    p1->BuyTicket();
//    p2->BuyTicket();
//    //func(&person);   // 输出：Person buying a ticket
//    //func(&student);  // 输出：Student buying a ticket with discount
//}

//// ====== 票类体系 ======
//class Ticket
//{
//public:
//	virtual void Print() const {
//		cout << "Regular ticket" << endl;
//	}
//};
//class StudentTicket:public Ticket
//{
//public:
//	void Print() const override {
//		cout << "Student discount ticket" << endl;
//	}
//};
//// ====== 人类体系 ======
//class Person
//{
//public:
//	virtual Ticket* Buyticket() const
//	{
//		Ticket* ticket = new Ticket();
//		cout << "Person buys ticket" << endl;
//		return ticket;
//	}
//};
//
//class Student :public Person
//{
//public:
//	virtual StudentTicket* Buyticket() const override
//	{
//		StudentTicket* ticket = new StudentTicket();
//		cout << "Student buys discounted ticket" << endl;
//		return ticket;
//	}
//};
//
//void PrintTicketInfo(const Person* p) {
//	Ticket* ticket = p->Buyticket();  // ✅ 第一次多态调用（Person 的虚函数）
//	ticket->Print();                  // ✅ 第二次多态调用（Ticket 的虚函数）
//	delete ticket;
//}
//
//int main()
//{
//	Student s;
//	PrintTicketInfo(&s);
//	Person* p = new Student();
//	PrintTicketInfo(p);
//	return 0;
//}


//class Person 
//{
//public:
//    virtual void Speak() const { cout << "Person speaking" << endl; }
//    virtual ~Person() { cout << "Person destroyed" << endl; }
//};
//
//class Student : public Person 
//{
//public:
//    ~Student() { cout << "Student destroyed" << endl; }
//};
//
//int main() 
//{
//    Person* p = new Student();  // 用父类指针指向子类对象
//    delete p;                   // 🚨 只会调用 Person::~Person()
//                                //Student 的析构函数没被调用 → 学生身上的资源没有被释放 → 内存泄漏！
//}


//隐藏 vs 重载 vs 覆盖（override）
#include <iostream>
using namespace std;

class Base {
public:
    void Show() {
        cout << "Base::Show()" << endl;
    }

    void Show(int x) {
        cout << "Base::Show(int): " << x << endl;
    }

    virtual void Speak() {
        cout << "Base speaking" << endl;
    }
};

class Derived : public Base {
public:
    // 👇 这是隐藏（hiding），名字一样，参数不同
    void Show(const string& x) {
        cout << "Derived::Show(const string&): " << x << endl;
    }

    // 👇 这是覆盖（override），虚函数 + 同签名
    void Speak() override {
        cout << "Derived speaking" << endl;
    }

    // 👇 这是重载（overload），在同一个类作用域中参数不同
    void Speak(const string& lang) {
        cout << "Derived speaking " << lang << endl;
    }
};

int main()
{
    Derived d;
    //d.Show(30);   // ❌ 报错！Base::Show() 和 Show(int) 被隐藏了！
    d.Show("hello");     // ✅ 调用 Derived::Show(const string&)

    // 显式引入父类函数，解除隐藏
    d.Base::Show();        // ✅ 调用 Base::Show()
    d.Base::Show(42);      // ✅ 调用 Base::Show(int)

    Base* b = new Derived();
    b->Speak();
    return 0;
}
